+Thu Jul 23 00:11:39 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/testgtkrc: introduce testbindings on C-1 for buttons,
+ to check out binding priorities. someone should really write
+ gtkrc-mode for emacs.
+
+ * gtk/gtkwidget.c (gtk_widget_class_init): remove ugly bindings test.
+ * gtk/testgtk.c (main): and move it here ;). this test says something
+ on release of C-9. (this works only if the mouse pointer is on a
+ spinbutton and there is no focus widget).
+
+ * gtk/gtkrc.h:
+ * gtk/gtkrc.c:
+ export gtk_rc_parse_color, gtk_rc_parse_state and a new function
+ gtk_rc_parse_priority to parse path priority types.
+ export rc tokens.
+ feature binding parsing.
+
+Wed Jul 22 23:41:17 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkbindings.h:
+ * gtk/gtkbindings.c: new function gtk_binding_parse_binding() to
+ feature binding parsing in rc files.
+ * gtk/gtkbindings.c (gtk_binding_set_new): bug fix.
+ * gtk/gtkbindings.c (gtk_binding_pattern_compare): bug fix, we used to
+ order the bindings with lowest priority first.
+
Wed Jul 22 15:21:08 PDT 1998 Manish Singh <yosh@gimp.org>
* gdk/gdkrgb.c: actually builds and runs properly on big
+Thu Jul 23 00:11:39 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/testgtkrc: introduce testbindings on C-1 for buttons,
+ to check out binding priorities. someone should really write
+ gtkrc-mode for emacs.
+
+ * gtk/gtkwidget.c (gtk_widget_class_init): remove ugly bindings test.
+ * gtk/testgtk.c (main): and move it here ;). this test says something
+ on release of C-9. (this works only if the mouse pointer is on a
+ spinbutton and there is no focus widget).
+
+ * gtk/gtkrc.h:
+ * gtk/gtkrc.c:
+ export gtk_rc_parse_color, gtk_rc_parse_state and a new function
+ gtk_rc_parse_priority to parse path priority types.
+ export rc tokens.
+ feature binding parsing.
+
+Wed Jul 22 23:41:17 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkbindings.h:
+ * gtk/gtkbindings.c: new function gtk_binding_parse_binding() to
+ feature binding parsing in rc files.
+ * gtk/gtkbindings.c (gtk_binding_set_new): bug fix.
+ * gtk/gtkbindings.c (gtk_binding_pattern_compare): bug fix, we used to
+ order the bindings with lowest priority first.
+
Wed Jul 22 15:21:08 PDT 1998 Manish Singh <yosh@gimp.org>
* gdk/gdkrgb.c: actually builds and runs properly on big
+Thu Jul 23 00:11:39 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/testgtkrc: introduce testbindings on C-1 for buttons,
+ to check out binding priorities. someone should really write
+ gtkrc-mode for emacs.
+
+ * gtk/gtkwidget.c (gtk_widget_class_init): remove ugly bindings test.
+ * gtk/testgtk.c (main): and move it here ;). this test says something
+ on release of C-9. (this works only if the mouse pointer is on a
+ spinbutton and there is no focus widget).
+
+ * gtk/gtkrc.h:
+ * gtk/gtkrc.c:
+ export gtk_rc_parse_color, gtk_rc_parse_state and a new function
+ gtk_rc_parse_priority to parse path priority types.
+ export rc tokens.
+ feature binding parsing.
+
+Wed Jul 22 23:41:17 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkbindings.h:
+ * gtk/gtkbindings.c: new function gtk_binding_parse_binding() to
+ feature binding parsing in rc files.
+ * gtk/gtkbindings.c (gtk_binding_set_new): bug fix.
+ * gtk/gtkbindings.c (gtk_binding_pattern_compare): bug fix, we used to
+ order the bindings with lowest priority first.
+
Wed Jul 22 15:21:08 PDT 1998 Manish Singh <yosh@gimp.org>
* gdk/gdkrgb.c: actually builds and runs properly on big
+Thu Jul 23 00:11:39 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/testgtkrc: introduce testbindings on C-1 for buttons,
+ to check out binding priorities. someone should really write
+ gtkrc-mode for emacs.
+
+ * gtk/gtkwidget.c (gtk_widget_class_init): remove ugly bindings test.
+ * gtk/testgtk.c (main): and move it here ;). this test says something
+ on release of C-9. (this works only if the mouse pointer is on a
+ spinbutton and there is no focus widget).
+
+ * gtk/gtkrc.h:
+ * gtk/gtkrc.c:
+ export gtk_rc_parse_color, gtk_rc_parse_state and a new function
+ gtk_rc_parse_priority to parse path priority types.
+ export rc tokens.
+ feature binding parsing.
+
+Wed Jul 22 23:41:17 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkbindings.h:
+ * gtk/gtkbindings.c: new function gtk_binding_parse_binding() to
+ feature binding parsing in rc files.
+ * gtk/gtkbindings.c (gtk_binding_set_new): bug fix.
+ * gtk/gtkbindings.c (gtk_binding_pattern_compare): bug fix, we used to
+ order the bindings with lowest priority first.
+
Wed Jul 22 15:21:08 PDT 1998 Manish Singh <yosh@gimp.org>
* gdk/gdkrgb.c: actually builds and runs properly on big
+Thu Jul 23 00:11:39 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/testgtkrc: introduce testbindings on C-1 for buttons,
+ to check out binding priorities. someone should really write
+ gtkrc-mode for emacs.
+
+ * gtk/gtkwidget.c (gtk_widget_class_init): remove ugly bindings test.
+ * gtk/testgtk.c (main): and move it here ;). this test says something
+ on release of C-9. (this works only if the mouse pointer is on a
+ spinbutton and there is no focus widget).
+
+ * gtk/gtkrc.h:
+ * gtk/gtkrc.c:
+ export gtk_rc_parse_color, gtk_rc_parse_state and a new function
+ gtk_rc_parse_priority to parse path priority types.
+ export rc tokens.
+ feature binding parsing.
+
+Wed Jul 22 23:41:17 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkbindings.h:
+ * gtk/gtkbindings.c: new function gtk_binding_parse_binding() to
+ feature binding parsing in rc files.
+ * gtk/gtkbindings.c (gtk_binding_set_new): bug fix.
+ * gtk/gtkbindings.c (gtk_binding_pattern_compare): bug fix, we used to
+ order the bindings with lowest priority first.
+
Wed Jul 22 15:21:08 PDT 1998 Manish Singh <yosh@gimp.org>
* gdk/gdkrgb.c: actually builds and runs properly on big
+Thu Jul 23 00:11:39 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/testgtkrc: introduce testbindings on C-1 for buttons,
+ to check out binding priorities. someone should really write
+ gtkrc-mode for emacs.
+
+ * gtk/gtkwidget.c (gtk_widget_class_init): remove ugly bindings test.
+ * gtk/testgtk.c (main): and move it here ;). this test says something
+ on release of C-9. (this works only if the mouse pointer is on a
+ spinbutton and there is no focus widget).
+
+ * gtk/gtkrc.h:
+ * gtk/gtkrc.c:
+ export gtk_rc_parse_color, gtk_rc_parse_state and a new function
+ gtk_rc_parse_priority to parse path priority types.
+ export rc tokens.
+ feature binding parsing.
+
+Wed Jul 22 23:41:17 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkbindings.h:
+ * gtk/gtkbindings.c: new function gtk_binding_parse_binding() to
+ feature binding parsing in rc files.
+ * gtk/gtkbindings.c (gtk_binding_set_new): bug fix.
+ * gtk/gtkbindings.c (gtk_binding_pattern_compare): bug fix, we used to
+ order the bindings with lowest priority first.
+
Wed Jul 22 15:21:08 PDT 1998 Manish Singh <yosh@gimp.org>
* gdk/gdkrgb.c: actually builds and runs properly on big
+Thu Jul 23 00:11:39 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/testgtkrc: introduce testbindings on C-1 for buttons,
+ to check out binding priorities. someone should really write
+ gtkrc-mode for emacs.
+
+ * gtk/gtkwidget.c (gtk_widget_class_init): remove ugly bindings test.
+ * gtk/testgtk.c (main): and move it here ;). this test says something
+ on release of C-9. (this works only if the mouse pointer is on a
+ spinbutton and there is no focus widget).
+
+ * gtk/gtkrc.h:
+ * gtk/gtkrc.c:
+ export gtk_rc_parse_color, gtk_rc_parse_state and a new function
+ gtk_rc_parse_priority to parse path priority types.
+ export rc tokens.
+ feature binding parsing.
+
+Wed Jul 22 23:41:17 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkbindings.h:
+ * gtk/gtkbindings.c: new function gtk_binding_parse_binding() to
+ feature binding parsing in rc files.
+ * gtk/gtkbindings.c (gtk_binding_set_new): bug fix.
+ * gtk/gtkbindings.c (gtk_binding_pattern_compare): bug fix, we used to
+ order the bindings with lowest priority first.
+
Wed Jul 22 15:21:08 PDT 1998 Manish Singh <yosh@gimp.org>
* gdk/gdkrgb.c: actually builds and runs properly on big
(bottom-to-top GTK_PROGRESS_BOTTOM_TO_TOP)
(top-to-bottom GTK_PROGRESS_TOP_TO_BOTTOM))
+; enumerations from "./gtkrc.h"
+
+(define-enum GtkRcTokenType
+ (invalid GTK_RC_TOKEN_INVALID)
+ (include GTK_RC_TOKEN_INCLUDE)
+ (normal GTK_RC_TOKEN_NORMAL)
+ (active GTK_RC_TOKEN_ACTIVE)
+ (prelight GTK_RC_TOKEN_PRELIGHT)
+ (selected GTK_RC_TOKEN_SELECTED)
+ (insensitive GTK_RC_TOKEN_INSENSITIVE)
+ (fg GTK_RC_TOKEN_FG)
+ (bg GTK_RC_TOKEN_BG)
+ (base GTK_RC_TOKEN_BASE)
+ (text GTK_RC_TOKEN_TEXT)
+ (font GTK_RC_TOKEN_FONT)
+ (fontset GTK_RC_TOKEN_FONTSET)
+ (bg-pixmap GTK_RC_TOKEN_BG_PIXMAP)
+ (pixmap-path GTK_RC_TOKEN_PIXMAP_PATH)
+ (style GTK_RC_TOKEN_STYLE)
+ (binding GTK_RC_TOKEN_BINDING)
+ (bind GTK_RC_TOKEN_BIND)
+ (widget GTK_RC_TOKEN_WIDGET)
+ (widget-class GTK_RC_TOKEN_WIDGET_CLASS)
+ (class GTK_RC_TOKEN_CLASS)
+ (lowest GTK_RC_TOKEN_LOWEST)
+ (gtk GTK_RC_TOKEN_GTK)
+ (application GTK_RC_TOKEN_APPLICATION)
+ (rc GTK_RC_TOKEN_RC)
+ (highest GTK_RC_TOKEN_HIGHEST)
+ (last GTK_RC_TOKEN_LAST))
+
; enumerations from "./gtkspinbutton.h"
(define-enum GtkSpinButtonUpdatePolicy
#include "gtkbindings.h"
#include "gtksignal.h"
#include "gtkwidget.h"
+#include "gtkrc.h"
/* --- defines --- */
valid = FALSE;
break;
case GTK_TYPE_STRING:
- if (param_ftype == GTK_TYPE_STRING)
+ if (args->arg_type == GTK_TYPE_STRING &&
+ param_ftype == GTK_TYPE_STRING)
GTK_VALUE_STRING (*params) = args->d.string_data;
- else if (param_ftype == GTK_TYPE_ENUM ||
- param_ftype == GTK_TYPE_FLAGS)
+ else if (args->arg_type == GTK_TYPE_IDENTIFIER &&
+ (param_ftype == GTK_TYPE_ENUM ||
+ param_ftype == GTK_TYPE_FLAGS))
{
/* FIXME: we need identifier lookups here */
valid = FALSE;
binding_set->entries = NULL;
binding_set->current = NULL;
- binding_set_list = g_slist_prepend (NULL, binding_set);
+ binding_set_list = g_slist_prepend (binding_set_list, binding_set);
return binding_set;
}
}
static gint
-gtk_binding_pattern_compare (gconstpointer a,
- gconstpointer b)
+gtk_binding_pattern_compare (gconstpointer new_pattern,
+ gconstpointer existing_pattern)
{
- register const GtkPatternSpec *pa = a;
- register const GtkPatternSpec *pb = b;
+ register const GtkPatternSpec *np = new_pattern;
+ register const GtkPatternSpec *ep = existing_pattern;
- return pa->seq_id < pb->seq_id ? -1 : 1;
+ /* walk the list as long as the existing patterns have
+ * higher priorities.
+ */
+
+ return np->seq_id < ep->seq_id;
}
static inline GSList*
g_free (pspec->pattern_reversed);
pspec->pattern_reversed = NULL;
}
+
+static guint
+gtk_binding_parse_signal (GScanner *scanner,
+ GtkBindingSet *binding_set,
+ guint keyval,
+ guint modifiers)
+{
+ gchar *signal;
+ guint expected_token = 0;
+ GSList *args;
+ GSList *slist;
+ gboolean done;
+ gboolean negate;
+ gboolean need_arg;
+ gboolean seen_comma;
+
+ g_return_val_if_fail (scanner != NULL, G_TOKEN_ERROR);
+
+ g_scanner_get_next_token (scanner);
+ if (scanner->token != G_TOKEN_STRING)
+ return G_TOKEN_STRING;
+ g_scanner_peek_next_token (scanner);
+ if (scanner->next_token != '(')
+ {
+ g_scanner_get_next_token (scanner);
+ return '(';
+ }
+ signal = g_strdup (scanner->value.v_string);
+ g_scanner_get_next_token (scanner);
+
+ negate = FALSE;
+ args = NULL;
+ done = FALSE;
+ need_arg = TRUE;
+ seen_comma = FALSE;
+ scanner->config->scan_symbols = FALSE;
+ do
+ {
+ if (need_arg)
+ expected_token = G_TOKEN_INT;
+ else
+ expected_token = ')';
+ g_scanner_get_next_token (scanner);
+ switch (scanner->token)
+ {
+ GtkBindingArg *arg;
+
+ case G_TOKEN_FLOAT:
+ if (need_arg)
+ {
+ need_arg = FALSE;
+ arg = g_new (GtkBindingArg, 1);
+ arg->arg_type = GTK_TYPE_DOUBLE;
+ arg->d.double_data = scanner->value.v_float;
+ if (negate)
+ {
+ arg->d.double_data = - arg->d.double_data;
+ negate = FALSE;
+ }
+ args = g_slist_prepend (args, arg);
+ }
+ else
+ done = TRUE;
+ break;
+ case G_TOKEN_INT:
+ if (need_arg)
+ {
+ need_arg = FALSE;
+ arg = g_new (GtkBindingArg, 1);
+ arg->arg_type = GTK_TYPE_LONG;
+ arg->d.long_data = scanner->value.v_int;
+ if (negate)
+ {
+ arg->d.long_data = - arg->d.long_data;
+ negate = FALSE;
+ }
+ args = g_slist_prepend (args, arg);
+ }
+ else
+ done = TRUE;
+ break;
+ case G_TOKEN_STRING:
+ if (need_arg && !negate)
+ {
+ need_arg = FALSE;
+ arg = g_new (GtkBindingArg, 1);
+ arg->arg_type = GTK_TYPE_STRING;
+ arg->d.string_data = g_strdup (scanner->value.v_string);
+ args = g_slist_prepend (args, arg);
+ }
+ else
+ done = TRUE;
+ break;
+ case G_TOKEN_IDENTIFIER:
+ if (need_arg && !negate)
+ {
+ need_arg = FALSE;
+ arg = g_new (GtkBindingArg, 1);
+ arg->arg_type = GTK_TYPE_IDENTIFIER;
+ arg->d.string_data = g_strdup (scanner->value.v_identifier);
+ args = g_slist_prepend (args, arg);
+ }
+ else
+ done = TRUE;
+ break;
+ case '-':
+ if (!need_arg)
+ done = TRUE;
+ else if (negate)
+ {
+ expected_token = G_TOKEN_INT;
+ done = TRUE;
+ }
+ else
+ negate = TRUE;
+ break;
+ case ',':
+ seen_comma = TRUE;
+ if (need_arg)
+ done = TRUE;
+ else
+ need_arg = TRUE;
+ break;
+ case ')':
+ if (!(need_arg && seen_comma) && !negate)
+ {
+ args = g_slist_reverse (args);
+ gtk_binding_entry_add_signall (binding_set,
+ keyval,
+ modifiers,
+ signal,
+ args);
+ expected_token = G_TOKEN_NONE;
+ }
+ done = TRUE;
+ break;
+ default:
+ done = TRUE;
+ break;
+ }
+ }
+ while (!done);
+ scanner->config->scan_symbols = TRUE;
+
+ for (slist = args; slist; slist = slist->next)
+ {
+ GtkBindingArg *arg;
+
+ arg = slist->data;
+ if (GTK_FUNDAMENTAL_TYPE (arg->arg_type) == GTK_TYPE_STRING)
+ g_free (arg->d.string_data);
+ g_free (arg);
+ }
+ g_slist_free (args);
+ g_free (signal);
+
+ return expected_token;
+}
+
+static inline guint
+gtk_binding_parse_bind (GScanner *scanner,
+ GtkBindingSet *binding_set)
+{
+ guint keyval = 0;
+ guint modifiers = 0;
+
+ g_return_val_if_fail (scanner != NULL, G_TOKEN_ERROR);
+
+ g_scanner_get_next_token (scanner);
+ if (scanner->token != GTK_RC_TOKEN_BIND)
+ return GTK_RC_TOKEN_BIND;
+ g_scanner_get_next_token (scanner);
+ if (scanner->token != G_TOKEN_STRING)
+ return G_TOKEN_STRING;
+ gtk_accelerator_parse (scanner->value.v_string, &keyval, &modifiers);
+ modifiers &= BINDING_MOD_MASK ();
+ if (keyval == 0)
+ return G_TOKEN_STRING;
+
+ g_scanner_get_next_token (scanner);
+ if (scanner->token != '{')
+ return '{';
+
+ gtk_binding_entry_clear (binding_set, keyval, modifiers);
+
+ g_scanner_peek_next_token (scanner);
+ while (scanner->next_token != '}')
+ {
+ switch (scanner->next_token)
+ {
+ guint expected_token;
+
+ case G_TOKEN_STRING:
+ expected_token = gtk_binding_parse_signal (scanner,
+ binding_set,
+ keyval,
+ modifiers);
+ if (expected_token != G_TOKEN_NONE)
+ return expected_token;
+ break;
+ default:
+ g_scanner_get_next_token (scanner);
+ return '}';
+ }
+ g_scanner_peek_next_token (scanner);
+ }
+ g_scanner_get_next_token (scanner);
+
+ return G_TOKEN_NONE;
+}
+
+guint
+gtk_binding_parse_binding (GScanner *scanner)
+{
+ gchar *name;
+ GtkBindingSet *binding_set;
+
+ g_return_val_if_fail (scanner != NULL, G_TOKEN_ERROR);
+
+ g_scanner_get_next_token (scanner);
+ if (scanner->token != GTK_RC_TOKEN_BINDING)
+ return GTK_RC_TOKEN_BINDING;
+ g_scanner_get_next_token (scanner);
+ if (scanner->token != G_TOKEN_STRING)
+ return G_TOKEN_STRING;
+ name = g_strdup (scanner->value.v_string);
+
+ g_scanner_get_next_token (scanner);
+ if (scanner->token != '{')
+ {
+ g_free (name);
+ return G_TOKEN_STRING;
+ }
+
+ binding_set = gtk_binding_set_find (name);
+ if (!binding_set)
+ binding_set = gtk_binding_set_new (name);
+ g_free (name);
+
+ g_scanner_peek_next_token (scanner);
+ while (scanner->next_token != '}')
+ {
+ switch (scanner->next_token)
+ {
+ guint expected_token;
+
+ case GTK_RC_TOKEN_BIND:
+ expected_token = gtk_binding_parse_bind (scanner, binding_set);
+ if (expected_token != G_TOKEN_NONE)
+ return expected_token;
+ break;
+ default:
+ g_scanner_get_next_token (scanner);
+ return '}';
+ }
+ g_scanner_peek_next_token (scanner);
+ }
+ g_scanner_get_next_token (scanner);
+
+ return G_TOKEN_NONE;
+}
+
guint modifiers,
const gchar *signal_name,
GSList *binding_args);
+guint gtk_binding_parse_binding (GScanner *scanner);
GtkRcStyle *rc_style);
static guint gtk_rc_parse_fontset (GScanner *scanner,
GtkRcStyle *rc_style);
-static guint gtk_rc_parse_state (GScanner *scanner,
- GtkStateType *state);
-static guint gtk_rc_parse_color (GScanner *scanner,
- GdkColor *color);
static guint gtk_rc_parse_pixmap_path (GScanner *scanner);
static void gtk_rc_parse_pixmap_path_string (gchar *pix_path);
static char* gtk_rc_find_pixmap_in_path (GScanner *scanner,
) /* cset_identifier_first */,
(
G_CSET_a_2_z
- "_0123456789"
+ "_-0123456789"
G_CSET_A_2_Z
- G_CSET_LATINS
- G_CSET_LATINC
) /* cset_identifier_nth */,
( "#\n" ) /* cpair_comment_single */,
TRUE /* scan_string_dq */,
TRUE /* numbers_2_int */,
FALSE /* int_2_float */,
- TRUE /* identifier_2_string */,
+ FALSE /* identifier_2_string */,
TRUE /* char_2_token */,
TRUE /* symbol_2_token */,
-};
-
-enum {
- TOKEN_INVALID = G_TOKEN_LAST,
- TOKEN_INCLUDE,
- TOKEN_NORMAL,
- TOKEN_ACTIVE,
- TOKEN_PRELIGHT,
- TOKEN_SELECTED,
- TOKEN_INSENSITIVE,
- TOKEN_FG,
- TOKEN_BG,
- TOKEN_BASE,
- TOKEN_TEXT,
- TOKEN_FONT,
- TOKEN_FONTSET,
- TOKEN_BG_PIXMAP,
- TOKEN_PIXMAP_PATH,
- TOKEN_STYLE,
- TOKEN_BINDING,
- TOKEN_WIDGET,
- TOKEN_WIDGET_CLASS,
- TOKEN_CLASS,
- TOKEN_LAST
+ FALSE /* scope_0_fallback */,
};
static struct
gchar *name;
guint token;
} symbols[] = {
- { "include", TOKEN_INCLUDE },
- { "NORMAL", TOKEN_NORMAL },
- { "ACTIVE", TOKEN_ACTIVE },
- { "PRELIGHT", TOKEN_PRELIGHT },
- { "SELECTED", TOKEN_SELECTED },
- { "INSENSITIVE", TOKEN_INSENSITIVE },
- { "fg", TOKEN_FG },
- { "bg", TOKEN_BG },
- { "base", TOKEN_BASE },
- { "text", TOKEN_TEXT },
- { "font", TOKEN_FONT },
- { "fontset", TOKEN_FONTSET },
- { "bg_pixmap", TOKEN_BG_PIXMAP },
- { "pixmap_path", TOKEN_PIXMAP_PATH },
- { "style", TOKEN_STYLE },
- { "binding", TOKEN_BINDING },
- { "widget", TOKEN_WIDGET },
- { "widget_class", TOKEN_WIDGET_CLASS },
- { "class", TOKEN_CLASS },
+ { "include", GTK_RC_TOKEN_INCLUDE },
+ { "NORMAL", GTK_RC_TOKEN_NORMAL },
+ { "ACTIVE", GTK_RC_TOKEN_ACTIVE },
+ { "PRELIGHT", GTK_RC_TOKEN_PRELIGHT },
+ { "SELECTED", GTK_RC_TOKEN_SELECTED },
+ { "INSENSITIVE", GTK_RC_TOKEN_INSENSITIVE },
+ { "fg", GTK_RC_TOKEN_FG },
+ { "bg", GTK_RC_TOKEN_BG },
+ { "base", GTK_RC_TOKEN_BASE },
+ { "text", GTK_RC_TOKEN_TEXT },
+ { "font", GTK_RC_TOKEN_FONT },
+ { "fontset", GTK_RC_TOKEN_FONTSET },
+ { "bg_pixmap", GTK_RC_TOKEN_BG_PIXMAP },
+ { "pixmap_path", GTK_RC_TOKEN_PIXMAP_PATH },
+ { "style", GTK_RC_TOKEN_STYLE },
+ { "binding", GTK_RC_TOKEN_BINDING },
+ { "bind", GTK_RC_TOKEN_BIND },
+ { "widget", GTK_RC_TOKEN_WIDGET },
+ { "widget_class", GTK_RC_TOKEN_WIDGET_CLASS },
+ { "class", GTK_RC_TOKEN_CLASS },
+ { "lowest", GTK_RC_TOKEN_LOWEST },
+ { "gtk", GTK_RC_TOKEN_GTK },
+ { "application", GTK_RC_TOKEN_APPLICATION },
+ { "rc", GTK_RC_TOKEN_RC },
+ { "highest", GTK_RC_TOKEN_HIGHEST },
};
-static guint nsymbols = sizeof (symbols) / sizeof (symbols[0]);
+
+static guint n_symbols = sizeof (symbols) / sizeof (symbols[0]);
static GHashTable *rc_style_ht = NULL;
static GSList *gtk_rc_sets_widget = NULL;
g_scanner_input_text (scanner, input_string, strlen (input_string));
}
scanner->input_name = input_name;
-
+
g_scanner_freeze_symbol_table (scanner);
- for (i = 0; i < nsymbols; i++)
+ for (i = 0; i < n_symbols; i++)
g_scanner_add_symbol (scanner, symbols[i].name, GINT_TO_POINTER (symbols[i].token));
g_scanner_thaw_symbol_table (scanner);
gchar *msg;
msg = NULL;
- if (expected_token > TOKEN_INVALID &&
- expected_token < TOKEN_LAST)
- {
- for (i = 0; i < nsymbols; i++)
- if (symbols[i].token == expected_token)
- msg = symbols[i].name;
- if (msg)
- msg = g_strconcat ("e.g. `", msg, "'", NULL);
- }
- if (scanner->token > TOKEN_INVALID &&
- scanner->token < TOKEN_LAST)
+ symbol_name = NULL;
+ if (scanner->scope_id == 0)
{
- symbol_name = "???";
- for (i = 0; i < nsymbols; i++)
- if (symbols[i].token == scanner->token)
- symbol_name = symbols[i].name;
+ /* if we are in scope 0, we know the symbol names
+ * that are associated with certaintoken values.
+ * so we look them up to make the error messages
+ * more readable.
+ */
+ if (expected_token > GTK_RC_TOKEN_INVALID &&
+ expected_token < GTK_RC_TOKEN_LAST)
+ {
+ for (i = 0; i < n_symbols; i++)
+ if (symbols[i].token == expected_token)
+ msg = symbols[i].name;
+ if (msg)
+ msg = g_strconcat ("e.g. `", msg, "'", NULL);
+ }
+ if (scanner->token > GTK_RC_TOKEN_INVALID &&
+ scanner->token < GTK_RC_TOKEN_LAST)
+ {
+ symbol_name = "???";
+ for (i = 0; i < n_symbols; i++)
+ if (symbols[i].token == scanner->token)
+ symbol_name = symbols[i].name;
+ }
}
- else
- symbol_name = NULL;
g_scanner_unexp_token (scanner,
expected_token,
NULL,
switch (token)
{
- case TOKEN_INCLUDE:
+ case GTK_RC_TOKEN_INCLUDE:
token = g_scanner_get_next_token (scanner);
- if (token != TOKEN_INCLUDE)
- return TOKEN_INCLUDE;
+ if (token != GTK_RC_TOKEN_INCLUDE)
+ return GTK_RC_TOKEN_INCLUDE;
token = g_scanner_get_next_token (scanner);
if (token != G_TOKEN_STRING)
gtk_rc_parse_file (scanner->value.v_string, FALSE);
return G_TOKEN_NONE;
- case TOKEN_STYLE:
+ case GTK_RC_TOKEN_STYLE:
return gtk_rc_parse_style (scanner);
- case TOKEN_PIXMAP_PATH:
+ case GTK_RC_TOKEN_BINDING:
+ return gtk_binding_parse_binding (scanner);
+
+ case GTK_RC_TOKEN_PIXMAP_PATH:
return gtk_rc_parse_pixmap_path (scanner);
- case TOKEN_WIDGET:
+ case GTK_RC_TOKEN_WIDGET:
return gtk_rc_parse_path_pattern (scanner);
- case TOKEN_WIDGET_CLASS:
+ case GTK_RC_TOKEN_WIDGET_CLASS:
return gtk_rc_parse_path_pattern (scanner);
- case TOKEN_CLASS:
+ case GTK_RC_TOKEN_CLASS:
return gtk_rc_parse_path_pattern (scanner);
default:
g_scanner_get_next_token (scanner);
- return /* G_TOKEN_SYMBOL */ TOKEN_STYLE;
+ return /* G_TOKEN_SYMBOL */ GTK_RC_TOKEN_STYLE;
}
}
gint i;
token = g_scanner_get_next_token (scanner);
- if (token != TOKEN_STYLE)
- return TOKEN_STYLE;
+ if (token != GTK_RC_TOKEN_STYLE)
+ return GTK_RC_TOKEN_STYLE;
token = g_scanner_get_next_token (scanner);
if (token != G_TOKEN_STRING)
{
switch (token)
{
- case TOKEN_BASE:
+ case GTK_RC_TOKEN_BASE:
token = gtk_rc_parse_base (scanner, rc_style->proto_style);
break;
- case TOKEN_BG:
+ case GTK_RC_TOKEN_BG:
token = gtk_rc_parse_bg (scanner, rc_style->proto_style);
break;
- case TOKEN_FG:
+ case GTK_RC_TOKEN_FG:
token = gtk_rc_parse_fg (scanner, rc_style->proto_style);
break;
- case TOKEN_TEXT:
+ case GTK_RC_TOKEN_TEXT:
token = gtk_rc_parse_text (scanner, rc_style->proto_style);
break;
- case TOKEN_BG_PIXMAP:
+ case GTK_RC_TOKEN_BG_PIXMAP:
token = gtk_rc_parse_bg_pixmap (scanner, rc_style);
break;
- case TOKEN_FONT:
+ case GTK_RC_TOKEN_FONT:
token = gtk_rc_parse_font (scanner, rc_style);
break;
- case TOKEN_FONTSET:
+ case GTK_RC_TOKEN_FONTSET:
token = gtk_rc_parse_fontset (scanner, rc_style);
break;
default:
guint token;
token = g_scanner_get_next_token (scanner);
- if (token != TOKEN_BASE)
- return TOKEN_BASE;
+ if (token != GTK_RC_TOKEN_BASE)
+ return GTK_RC_TOKEN_BASE;
token = gtk_rc_parse_state (scanner, &state);
if (token != G_TOKEN_NONE)
guint token;
token = g_scanner_get_next_token (scanner);
- if (token != TOKEN_BG)
- return TOKEN_BG;
+ if (token != GTK_RC_TOKEN_BG)
+ return GTK_RC_TOKEN_BG;
token = gtk_rc_parse_state (scanner, &state);
if (token != G_TOKEN_NONE)
guint token;
token = g_scanner_get_next_token (scanner);
- if (token != TOKEN_FG)
- return TOKEN_FG;
+ if (token != GTK_RC_TOKEN_FG)
+ return GTK_RC_TOKEN_FG;
token = gtk_rc_parse_state (scanner, &state);
if (token != G_TOKEN_NONE)
guint token;
token = g_scanner_get_next_token (scanner);
- if (token != TOKEN_TEXT)
- return TOKEN_TEXT;
+ if (token != GTK_RC_TOKEN_TEXT)
+ return GTK_RC_TOKEN_TEXT;
token = gtk_rc_parse_state (scanner, &state);
if (token != G_TOKEN_NONE)
gchar *pixmap_file;
token = g_scanner_get_next_token (scanner);
- if (token != TOKEN_BG_PIXMAP)
- return TOKEN_BG_PIXMAP;
+ if (token != GTK_RC_TOKEN_BG_PIXMAP)
+ return GTK_RC_TOKEN_BG_PIXMAP;
token = gtk_rc_parse_state (scanner, &state);
if (token != G_TOKEN_NONE)
guint token;
token = g_scanner_get_next_token (scanner);
- if (token != TOKEN_FONT)
- return TOKEN_FONT;
+ if (token != GTK_RC_TOKEN_FONT)
+ return GTK_RC_TOKEN_FONT;
token = g_scanner_get_next_token (scanner);
if (token != G_TOKEN_EQUAL_SIGN)
guint token;
token = g_scanner_get_next_token (scanner);
- if (token != TOKEN_FONTSET)
- return TOKEN_FONTSET;
+ if (token != GTK_RC_TOKEN_FONTSET)
+ return GTK_RC_TOKEN_FONTSET;
token = g_scanner_get_next_token (scanner);
if (token != G_TOKEN_EQUAL_SIGN)
return G_TOKEN_NONE;
}
-static guint
+guint
gtk_rc_parse_state (GScanner *scanner,
GtkStateType *state)
{
+ guint old_scope;
guint token;
+
+ g_return_val_if_fail (scanner != NULL, G_TOKEN_ERROR);
+ g_return_val_if_fail (state != NULL, G_TOKEN_ERROR);
+
+ /* we don't know where we got called from, so we reset the scope here.
+ * if we bail out due to errors, we *don't* reset the scope, so the
+ * error messaging code can make sense of our tokens.
+ */
+ old_scope = g_scanner_set_scope (scanner, 0);
token = g_scanner_get_next_token (scanner);
if (token != G_TOKEN_LEFT_BRACE)
token = g_scanner_get_next_token (scanner);
switch (token)
{
- case TOKEN_ACTIVE:
+ case GTK_RC_TOKEN_ACTIVE:
*state = GTK_STATE_ACTIVE;
break;
- case TOKEN_INSENSITIVE:
+ case GTK_RC_TOKEN_INSENSITIVE:
*state = GTK_STATE_INSENSITIVE;
break;
- case TOKEN_NORMAL:
+ case GTK_RC_TOKEN_NORMAL:
*state = GTK_STATE_NORMAL;
break;
- case TOKEN_PRELIGHT:
+ case GTK_RC_TOKEN_PRELIGHT:
*state = GTK_STATE_PRELIGHT;
break;
- case TOKEN_SELECTED:
+ case GTK_RC_TOKEN_SELECTED:
*state = GTK_STATE_SELECTED;
break;
default:
- return /* G_TOKEN_SYMBOL */ TOKEN_NORMAL;
+ return /* G_TOKEN_SYMBOL */ GTK_RC_TOKEN_NORMAL;
}
token = g_scanner_get_next_token (scanner);
if (token != G_TOKEN_RIGHT_BRACE)
return G_TOKEN_RIGHT_BRACE;
+ g_scanner_set_scope (scanner, old_scope);
+
return G_TOKEN_NONE;
}
-static guint
+guint
+gtk_rc_parse_priority (GScanner *scanner,
+ GtkPathPriorityType *priority)
+{
+ guint old_scope;
+ guint token;
+
+ g_return_val_if_fail (scanner != NULL, G_TOKEN_ERROR);
+ g_return_val_if_fail (priority != NULL, G_TOKEN_ERROR);
+
+ /* we don't know where we got called from, so we reset the scope here.
+ * if we bail out due to errors, we *don't* reset the scope, so the
+ * error messaging code can make sense of our tokens.
+ */
+ old_scope = g_scanner_set_scope (scanner, 0);
+
+ token = g_scanner_get_next_token (scanner);
+ if (token != ':')
+ return ':';
+
+ token = g_scanner_get_next_token (scanner);
+ switch (token)
+ {
+ case GTK_RC_TOKEN_LOWEST:
+ *priority = GTK_PATH_PRIO_LOWEST;
+ break;
+ case GTK_RC_TOKEN_GTK:
+ *priority = GTK_PATH_PRIO_GTK;
+ break;
+ case GTK_RC_TOKEN_APPLICATION:
+ *priority = GTK_PATH_PRIO_APPLICATION;
+ break;
+ case GTK_RC_TOKEN_RC:
+ *priority = GTK_PATH_PRIO_RC;
+ break;
+ case GTK_RC_TOKEN_HIGHEST:
+ *priority = GTK_PATH_PRIO_HIGHEST;
+ break;
+ default:
+ return /* G_TOKEN_SYMBOL */ GTK_RC_TOKEN_APPLICATION;
+ }
+
+ g_scanner_set_scope (scanner, old_scope);
+
+ return G_TOKEN_NONE;
+}
+
+guint
gtk_rc_parse_color (GScanner *scanner,
GdkColor *color)
{
guint token;
+
+ g_return_val_if_fail (scanner != NULL, G_TOKEN_ERROR);
+
+ /* we don't need to set our own scop here, because
+ * we don't need own symbols
+ */
token = g_scanner_get_next_token (scanner);
switch (token)
guint token;
token = g_scanner_get_next_token (scanner);
- if (token != TOKEN_PIXMAP_PATH)
- return TOKEN_PIXMAP_PATH;
+ if (token != GTK_RC_TOKEN_PIXMAP_PATH)
+ return GTK_RC_TOKEN_PIXMAP_PATH;
token = g_scanner_get_next_token (scanner);
if (token != G_TOKEN_STRING)
GtkPathType path_type;
gchar *pattern;
gboolean is_binding;
+ GtkPathPriorityType priority = GTK_PATH_PRIO_RC;
token = g_scanner_get_next_token (scanner);
switch (token)
{
- case TOKEN_WIDGET:
+ case GTK_RC_TOKEN_WIDGET:
path_type = GTK_PATH_WIDGET;
break;
- case TOKEN_WIDGET_CLASS:
+ case GTK_RC_TOKEN_WIDGET_CLASS:
path_type = GTK_PATH_WIDGET_CLASS;
break;
- case TOKEN_CLASS:
+ case GTK_RC_TOKEN_CLASS:
path_type = GTK_PATH_CLASS;
break;
default:
- return TOKEN_WIDGET_CLASS;
+ return GTK_RC_TOKEN_WIDGET_CLASS;
}
token = g_scanner_get_next_token (scanner);
pattern = g_strdup (scanner->value.v_string);
token = g_scanner_get_next_token (scanner);
- if (token == TOKEN_STYLE)
+ if (token == GTK_RC_TOKEN_STYLE)
is_binding = FALSE;
- else if (token == TOKEN_BINDING)
- is_binding = TRUE;
+ else if (token == GTK_RC_TOKEN_BINDING)
+ {
+ is_binding = TRUE;
+ if (g_scanner_peek_next_token (scanner) == ':')
+ {
+ token = gtk_rc_parse_priority (scanner, &priority);
+ if (token != G_TOKEN_NONE)
+ {
+ g_free (pattern);
+ return token;
+ }
+ }
+ }
else
{
g_free (pattern);
- return TOKEN_STYLE;
+ return GTK_RC_TOKEN_STYLE;
}
token = g_scanner_get_next_token (scanner);
g_free (pattern);
return G_TOKEN_STRING;
}
- gtk_binding_set_add_path (binding, path_type, pattern, GTK_PATH_PRIO_RC);
+ gtk_binding_set_add_path (binding, path_type, pattern, priority);
}
else
{
void gtk_rc_init (void);
void gtk_rc_parse (const gchar *filename);
void gtk_rc_parse_string (const gchar *rc_string);
-gboolean gtk_rc_reparse_all (void);
+gboolean gtk_rc_reparse_all (void);
GtkStyle* gtk_rc_get_style (GtkWidget *widget);
void gtk_rc_add_widget_name_style (GtkStyle *style,
const gchar *pattern);
/* Tell gtkrc to use a custom routine to load images specified in rc files instead of
* the default xpm-only loader
*/
-typedef GdkPixmap * (*GtkImageLoader) (GdkWindow *window,
+typedef GdkPixmap * (*GtkImageLoader) (GdkWindow *window,
GdkColormap *colormap,
GdkBitmap **mask,
GdkColor *transparent_color,
void gtk_rc_set_image_loader(GtkImageLoader loader);
+/* private functions/definitions */
+typedef enum {
+ GTK_RC_TOKEN_INVALID = G_TOKEN_LAST,
+ GTK_RC_TOKEN_INCLUDE,
+ GTK_RC_TOKEN_NORMAL,
+ GTK_RC_TOKEN_ACTIVE,
+ GTK_RC_TOKEN_PRELIGHT,
+ GTK_RC_TOKEN_SELECTED,
+ GTK_RC_TOKEN_INSENSITIVE,
+ GTK_RC_TOKEN_FG,
+ GTK_RC_TOKEN_BG,
+ GTK_RC_TOKEN_BASE,
+ GTK_RC_TOKEN_TEXT,
+ GTK_RC_TOKEN_FONT,
+ GTK_RC_TOKEN_FONTSET,
+ GTK_RC_TOKEN_BG_PIXMAP,
+ GTK_RC_TOKEN_PIXMAP_PATH,
+ GTK_RC_TOKEN_STYLE,
+ GTK_RC_TOKEN_BINDING,
+ GTK_RC_TOKEN_BIND,
+ GTK_RC_TOKEN_WIDGET,
+ GTK_RC_TOKEN_WIDGET_CLASS,
+ GTK_RC_TOKEN_CLASS,
+ GTK_RC_TOKEN_LOWEST,
+ GTK_RC_TOKEN_GTK,
+ GTK_RC_TOKEN_APPLICATION,
+ GTK_RC_TOKEN_RC,
+ GTK_RC_TOKEN_HIGHEST,
+ GTK_RC_TOKEN_LAST
+} GtkRcTokenType;
+
+guint gtk_rc_parse_color (GScanner *scanner,
+ GdkColor *color);
+guint gtk_rc_parse_state (GScanner *scanner,
+ GtkStateType *state);
+guint gtk_rc_parse_priority (GScanner *scanner,
+ GtkPathPriorityType *priority);
+
+
+
#ifdef __cplusplus
}
#endif /* __cplusplus */
extern GtkType GTK_TYPE_PRIVATE_FLAGS;
extern GtkType GTK_TYPE_PROGRESS_BAR_STYLE;
extern GtkType GTK_TYPE_PROGRESS_BAR_ORIENTATION;
+extern GtkType GTK_TYPE_RC_TOKEN_TYPE;
extern GtkType GTK_TYPE_SPIN_BUTTON_UPDATE_POLICY;
extern GtkType GTK_TYPE_SPIN_TYPE;
extern GtkType GTK_TYPE_TOOLBAR_CHILD_TYPE;
extern GtkType GTK_TYPE_GDK_EVENT;
extern GtkType GTK_TYPE_GDK_COLOR;
-#define GTK_TYPE_NUM_BUILTINS (104)
+#define GTK_TYPE_NUM_BUILTINS (105)
{ GTK_PROGRESS_TOP_TO_BOTTOM, "GTK_PROGRESS_TOP_TO_BOTTOM", "top-to-bottom" },
{ 0, NULL, NULL }
};
+static GtkEnumValue _gtk_rc_token_type_values[] = {
+ { GTK_RC_TOKEN_INVALID, "GTK_RC_TOKEN_INVALID", "invalid" },
+ { GTK_RC_TOKEN_INCLUDE, "GTK_RC_TOKEN_INCLUDE", "include" },
+ { GTK_RC_TOKEN_NORMAL, "GTK_RC_TOKEN_NORMAL", "normal" },
+ { GTK_RC_TOKEN_ACTIVE, "GTK_RC_TOKEN_ACTIVE", "active" },
+ { GTK_RC_TOKEN_PRELIGHT, "GTK_RC_TOKEN_PRELIGHT", "prelight" },
+ { GTK_RC_TOKEN_SELECTED, "GTK_RC_TOKEN_SELECTED", "selected" },
+ { GTK_RC_TOKEN_INSENSITIVE, "GTK_RC_TOKEN_INSENSITIVE", "insensitive" },
+ { GTK_RC_TOKEN_FG, "GTK_RC_TOKEN_FG", "fg" },
+ { GTK_RC_TOKEN_BG, "GTK_RC_TOKEN_BG", "bg" },
+ { GTK_RC_TOKEN_BASE, "GTK_RC_TOKEN_BASE", "base" },
+ { GTK_RC_TOKEN_TEXT, "GTK_RC_TOKEN_TEXT", "text" },
+ { GTK_RC_TOKEN_FONT, "GTK_RC_TOKEN_FONT", "font" },
+ { GTK_RC_TOKEN_FONTSET, "GTK_RC_TOKEN_FONTSET", "fontset" },
+ { GTK_RC_TOKEN_BG_PIXMAP, "GTK_RC_TOKEN_BG_PIXMAP", "bg-pixmap" },
+ { GTK_RC_TOKEN_PIXMAP_PATH, "GTK_RC_TOKEN_PIXMAP_PATH", "pixmap-path" },
+ { GTK_RC_TOKEN_STYLE, "GTK_RC_TOKEN_STYLE", "style" },
+ { GTK_RC_TOKEN_BINDING, "GTK_RC_TOKEN_BINDING", "binding" },
+ { GTK_RC_TOKEN_BIND, "GTK_RC_TOKEN_BIND", "bind" },
+ { GTK_RC_TOKEN_WIDGET, "GTK_RC_TOKEN_WIDGET", "widget" },
+ { GTK_RC_TOKEN_WIDGET_CLASS, "GTK_RC_TOKEN_WIDGET_CLASS", "widget-class" },
+ { GTK_RC_TOKEN_CLASS, "GTK_RC_TOKEN_CLASS", "class" },
+ { GTK_RC_TOKEN_LOWEST, "GTK_RC_TOKEN_LOWEST", "lowest" },
+ { GTK_RC_TOKEN_GTK, "GTK_RC_TOKEN_GTK", "gtk" },
+ { GTK_RC_TOKEN_APPLICATION, "GTK_RC_TOKEN_APPLICATION", "application" },
+ { GTK_RC_TOKEN_RC, "GTK_RC_TOKEN_RC", "rc" },
+ { GTK_RC_TOKEN_HIGHEST, "GTK_RC_TOKEN_HIGHEST", "highest" },
+ { GTK_RC_TOKEN_LAST, "GTK_RC_TOKEN_LAST", "last" },
+ { 0, NULL, NULL }
+};
static GtkEnumValue _gtk_spin_button_update_policy_values[] = {
{ GTK_UPDATE_ALWAYS, "GTK_UPDATE_ALWAYS", "always" },
{ GTK_UPDATE_IF_VALID, "GTK_UPDATE_IF_VALID", "if-valid" },
GTK_TYPE_ENUM, _gtk_progress_bar_style_values },
{ "GtkProgressBarOrientation", >K_TYPE_PROGRESS_BAR_ORIENTATION,
GTK_TYPE_ENUM, _gtk_progress_bar_orientation_values },
+ { "GtkRcTokenType", >K_TYPE_RC_TOKEN_TYPE,
+ GTK_TYPE_ENUM, _gtk_rc_token_type_values },
{ "GtkSpinButtonUpdatePolicy", >K_TYPE_SPIN_BUTTON_UPDATE_POLICY,
GTK_TYPE_ENUM, _gtk_spin_button_update_policy_values },
{ "GtkSpinType", >K_TYPE_SPIN_TYPE,
GtkType GTK_TYPE_PRIVATE_FLAGS = 0;
GtkType GTK_TYPE_PROGRESS_BAR_STYLE = 0;
GtkType GTK_TYPE_PROGRESS_BAR_ORIENTATION = 0;
+GtkType GTK_TYPE_RC_TOKEN_TYPE = 0;
GtkType GTK_TYPE_SPIN_BUTTON_UPDATE_POLICY = 0;
GtkType GTK_TYPE_SPIN_TYPE = 0;
GtkType GTK_TYPE_TOOLBAR_CHILD_TYPE = 0;
klass->other_event = NULL;
klass->debug_msg = gtk_widget_debug_msg;
-
- /* bindings test
- */
- {
- GtkBindingSet *binding_set;
-
- binding_set = gtk_binding_set_by_class (klass);
- gtk_binding_entry_add_signal (binding_set,
- '9', GDK_CONTROL_MASK | GDK_RELEASE_MASK,
- "debug_msg",
- 1,
- GTK_TYPE_STRING, "GtkWidgetClass test");
- }
}
static void
int
main (int argc, char *argv[])
{
+ GtkBindingSet *binding_set;
+
srand (time (NULL));
gtk_set_locale ();
gle_init (&argc, &argv);
#endif /* !HAVE_LIBGLE */
+ /* bindings test
+ */
+ binding_set = gtk_binding_set_by_class (gtk_type_class (GTK_TYPE_WIDGET));
+ gtk_binding_entry_add_signal (binding_set,
+ '9', GDK_CONTROL_MASK | GDK_RELEASE_MASK,
+ "debug_msg",
+ 1,
+ GTK_TYPE_STRING, "GtkWidgetClass <ctrl><release>9 test");
+
gtk_rc_parse ("testgtkrc");
create_main_window ();
widget_class "*Ruler" style "ruler"
widget_class "*GtkText" style "text"
widget "*GtkCurve" style "curve"
+
+binding "test1"
+{
+ bind "<ctrl>1" {
+ "debug-msg" ("hallo and")
+ "debug-msg" ("huhu")
+ }
+}
+
+binding "test2"
+{
+ bind "<ctrl>1" {
+ "debug-msg" ("jup!")
+ }
+}
+
+# possible priorities are (in ascending order):
+# lowest
+# gtk (used by gtk for internal class bindings)
+# application (for hard coded bindings on application basis)
+# rc (used implicitel by rc files)
+# highest
+class "GtkButton" binding "test1" # implicit : rc
+class "GtkButton" binding : highest "test2" # override "rc" priority
+
int
main (int argc, char *argv[])
{
+ GtkBindingSet *binding_set;
+
srand (time (NULL));
gtk_set_locale ();
gle_init (&argc, &argv);
#endif /* !HAVE_LIBGLE */
+ /* bindings test
+ */
+ binding_set = gtk_binding_set_by_class (gtk_type_class (GTK_TYPE_WIDGET));
+ gtk_binding_entry_add_signal (binding_set,
+ '9', GDK_CONTROL_MASK | GDK_RELEASE_MASK,
+ "debug_msg",
+ 1,
+ GTK_TYPE_STRING, "GtkWidgetClass <ctrl><release>9 test");
+
gtk_rc_parse ("testgtkrc");
create_main_window ();
widget_class "*Ruler" style "ruler"
widget_class "*GtkText" style "text"
widget "*GtkCurve" style "curve"
+
+binding "test1"
+{
+ bind "<ctrl>1" {
+ "debug-msg" ("hallo and")
+ "debug-msg" ("huhu")
+ }
+}
+
+binding "test2"
+{
+ bind "<ctrl>1" {
+ "debug-msg" ("jup!")
+ }
+}
+
+# possible priorities are (in ascending order):
+# lowest
+# gtk (used by gtk for internal class bindings)
+# application (for hard coded bindings on application basis)
+# rc (used implicitel by rc files)
+# highest
+class "GtkButton" binding "test1" # implicit : rc
+class "GtkButton" binding : highest "test2" # override "rc" priority
+
projects / gtk4.git / commitdiff